package co.edu.usbcali.correspondencia.presentation.businessDelegate;

import co.edu.usbcali.correspondencia.modelo.Administrador;
import co.edu.usbcali.correspondencia.modelo.Autorizacion;
import co.edu.usbcali.correspondencia.modelo.Ciudad;
import co.edu.usbcali.correspondencia.modelo.Concepto;
import co.edu.usbcali.correspondencia.modelo.Correspondencia;
import co.edu.usbcali.correspondencia.modelo.Cuenta;
import co.edu.usbcali.correspondencia.modelo.DetalleCorrespondencia;
import co.edu.usbcali.correspondencia.modelo.DetalleFactura;
import co.edu.usbcali.correspondencia.modelo.Division;
import co.edu.usbcali.correspondencia.modelo.DtoCorrespondencia;
import co.edu.usbcali.correspondencia.modelo.Estado;
import co.edu.usbcali.correspondencia.modelo.Factura;
import co.edu.usbcali.correspondencia.modelo.GrupoFamiliar;
import co.edu.usbcali.correspondencia.modelo.Inmueble;
import co.edu.usbcali.correspondencia.modelo.MovMesInmueble;
import co.edu.usbcali.correspondencia.modelo.Multa;
import co.edu.usbcali.correspondencia.modelo.Pais;
import co.edu.usbcali.correspondencia.modelo.Persona;
import co.edu.usbcali.correspondencia.modelo.Presupuesto;
import co.edu.usbcali.correspondencia.modelo.PropietarioInmueble;
import co.edu.usbcali.correspondencia.modelo.Recepcion;
import co.edu.usbcali.correspondencia.modelo.Reserva;
import co.edu.usbcali.correspondencia.modelo.Rubro;
import co.edu.usbcali.correspondencia.modelo.TipoCategoria;
import co.edu.usbcali.correspondencia.modelo.TipoConcepto;
import co.edu.usbcali.correspondencia.modelo.TipoCorrespondencia;
import co.edu.usbcali.correspondencia.modelo.TipoDocumento;
import co.edu.usbcali.correspondencia.modelo.TipoPersona;
import co.edu.usbcali.correspondencia.modelo.TipoUsuario;
import co.edu.usbcali.correspondencia.modelo.TipoVehiculo;
import co.edu.usbcali.correspondencia.modelo.TipoZonaComun;
import co.edu.usbcali.correspondencia.modelo.TipoZonaExtra;
import co.edu.usbcali.correspondencia.modelo.UnidadResidencial;
import co.edu.usbcali.correspondencia.modelo.Usuario;
import co.edu.usbcali.correspondencia.modelo.Vehiculo;
import co.edu.usbcali.correspondencia.modelo.ZonaComun;
import co.edu.usbcali.correspondencia.modelo.ZonaExtra;
import co.edu.usbcali.correspondencia.modelo.control.AdministradorLogic;
import co.edu.usbcali.correspondencia.modelo.control.AutorizacionLogic;
import co.edu.usbcali.correspondencia.modelo.control.CiudadLogic;
import co.edu.usbcali.correspondencia.modelo.control.ConceptoLogic;
import co.edu.usbcali.correspondencia.modelo.control.CorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.CuentaLogic;
import co.edu.usbcali.correspondencia.modelo.control.DetalleCorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.DetalleFacturaLogic;
import co.edu.usbcali.correspondencia.modelo.control.DivisionLogic;
import co.edu.usbcali.correspondencia.modelo.control.EstadoLogic;
import co.edu.usbcali.correspondencia.modelo.control.FacturaLogic;
import co.edu.usbcali.correspondencia.modelo.control.GrupoFamiliarLogic;
import co.edu.usbcali.correspondencia.modelo.control.IAdministradorLogic;
import co.edu.usbcali.correspondencia.modelo.control.IAutorizacionLogic;
import co.edu.usbcali.correspondencia.modelo.control.ICiudadLogic;
import co.edu.usbcali.correspondencia.modelo.control.IConceptoLogic;
import co.edu.usbcali.correspondencia.modelo.control.ICorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.ICuentaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IDetalleCorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IDetalleFacturaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IDivisionLogic;
import co.edu.usbcali.correspondencia.modelo.control.IEstadoLogic;
import co.edu.usbcali.correspondencia.modelo.control.IFacturaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IGrupoFamiliarLogic;
import co.edu.usbcali.correspondencia.modelo.control.IInmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.IMovMesInmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.IMultaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IPaisLogic;
import co.edu.usbcali.correspondencia.modelo.control.IPersonaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IPresupuestoLogic;
import co.edu.usbcali.correspondencia.modelo.control.IPropietarioInmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.IRecepcionLogic;
import co.edu.usbcali.correspondencia.modelo.control.IReservaLogic;
import co.edu.usbcali.correspondencia.modelo.control.IRubroLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoCategoriaLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoConceptoLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoCorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoDocumentoLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoPersonaLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoUsuarioLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoVehiculoLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoZonaComunLogic;
import co.edu.usbcali.correspondencia.modelo.control.ITipoZonaExtraLogic;
import co.edu.usbcali.correspondencia.modelo.control.IUnidadResidencialLogic;
import co.edu.usbcali.correspondencia.modelo.control.IUsuarioLogic;
import co.edu.usbcali.correspondencia.modelo.control.IVehiculoLogic;
import co.edu.usbcali.correspondencia.modelo.control.IZonaComunLogic;
import co.edu.usbcali.correspondencia.modelo.control.IZonaExtraLogic;
import co.edu.usbcali.correspondencia.modelo.control.InmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.MovMesInmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.MultaLogic;
import co.edu.usbcali.correspondencia.modelo.control.PaisLogic;
import co.edu.usbcali.correspondencia.modelo.control.PersonaLogic;
import co.edu.usbcali.correspondencia.modelo.control.PresupuestoLogic;
import co.edu.usbcali.correspondencia.modelo.control.PropietarioInmuebleLogic;
import co.edu.usbcali.correspondencia.modelo.control.RecepcionLogic;
import co.edu.usbcali.correspondencia.modelo.control.ReservaLogic;
import co.edu.usbcali.correspondencia.modelo.control.RubroLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoCategoriaLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoConceptoLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoCorrespondenciaLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoDocumentoLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoPersonaLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoUsuarioLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoVehiculoLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoZonaComunLogic;
import co.edu.usbcali.correspondencia.modelo.control.TipoZonaExtraLogic;
import co.edu.usbcali.correspondencia.modelo.control.UnidadResidencialLogic;
import co.edu.usbcali.correspondencia.modelo.control.UsuarioLogic;
import co.edu.usbcali.correspondencia.modelo.control.VehiculoLogic;
import co.edu.usbcali.correspondencia.modelo.control.ZonaComunLogic;
import co.edu.usbcali.correspondencia.modelo.control.ZonaExtraLogic;

import java.math.BigDecimal;

import java.util.Date;
import java.util.List;
import java.util.Set;


/**
* Use a Business Delegate to reduce coupling between presentation-tier clients and business services.
* The Business Delegate hides the underlying implementation details of the business service, such as lookup and access details of the EJB architecture.
*
* The Business Delegate acts as a client-side business abstraction; it provides an abstraction for, and thus hides,
* the implementation of the business services. Using a Business Delegate reduces the coupling between presentation-tier clients and
* the system's business services. Depending on the implementation strategy, the Business Delegate may shield clients from possible
* volatility in the implementation of the business service API. Potentially, this reduces the number of changes that must be made to the
* presentation-tier client code when the business service API or its underlying implementation changes.
*
* However, interface methods in the Business Delegate may still require modification if the underlying business service API changes.
* Admittedly, though, it is more likely that changes will be made to the business service rather than to the Business Delegate.
*
* Often, developers are skeptical when a design goal such as abstracting the business layer causes additional upfront work in return
* for future gains. However, using this pattern or its strategies results in only a small amount of additional upfront work and provides
* considerable benefits. The main benefit is hiding the details of the underlying service. For example, the client can become transparent
* to naming and lookup services. The Business Delegate also handles the exceptions from the business services, such as java.rmi.Remote
* exceptions, Java Messages Service (JMS) exceptions and so on. The Business Delegate may intercept such service level exceptions and
* generate application level exceptions instead. Application level exceptions are easier to handle by the clients, and may be user friendly.
* The Business Delegate may also transparently perform any retry or recovery operations necessary in the event of a service failure without
* exposing the client to the problem until it is determined that the problem is not resolvable. These gains present a compelling reason to
* use the pattern.
*
* Another benefit is that the delegate may cache results and references to remote business services. Caching can significantly improve performance,
* because it limits unnecessary and potentially costly round trips over the network.
*
* A Business Delegate uses a component called the Lookup Service. The Lookup Service is responsible for hiding the underlying implementation
* details of the business service lookup code. The Lookup Service may be written as part of the Delegate, but we recommend that it be
* implemented as a separate component, as outlined in the Service Locator pattern (See "Service Locator" on page 368.)
*
* When the Business Delegate is used with a Session Facade, typically there is a one-to-one relationship between the two.
* This one-to-one relationship exists because logic that might have been encapsulated in a Business Delegate relating to its interaction
* with multiple business services (creating a one-to-many relationship) will often be factored back into a Session Facade.
*
* Finally, it should be noted that this pattern could be used to reduce coupling between other tiers, not simply the presentation and the
* business tiers.
*
* @author Zathura Code Generator http://code.google.com/p/zathura
*
*/
public class BusinessDelegatorView {
    private BusinessDelegatorView() {
    }

    public static List<Administrador> getAdministrador()
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.getAdministrador();
    }

    public static void saveAdministrador(String admCodigo,
        String estCodigo_Estado, String perCedula_Persona)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.saveAdministrador(admCodigo, estCodigo_Estado,
            perCedula_Persona);
    }

    public static void deleteAdministrador(String admCodigo)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.deleteAdministrador(admCodigo);
    }

    public static void updateAdministrador(String admCodigo,
        String estCodigo_Estado, String perCedula_Persona)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        administradorLogic.updateAdministrador(admCodigo, estCodigo_Estado,
            perCedula_Persona);
    }

    public static Administrador getAdministrador(String admCodigo)
        throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();
        Administrador administrador = null;

        try {
            administrador = administradorLogic.getAdministrador(admCodigo);
        } catch (Exception e) {
            throw e;
        }

        return administrador;
    }

    public static List<Administrador> findByCriteriaInAdministrador(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Administrador> findPageAdministrador(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findPageAdministrador(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAdministrador() throws Exception {
        IAdministradorLogic administradorLogic = new AdministradorLogic();

        return administradorLogic.findTotalNumberAdministrador();
    }

    public static List<Autorizacion> getAutorizacion()
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.getAutorizacion();
    }

    public static void saveAutorizacion(String autCedVisitante,
        String autCodigo, String autDescripcionActi,
        String autDescripcionPermi, String autEmpresa, Date autFecha,
        String autNombreVisitante, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.saveAutorizacion(autCedVisitante, autCodigo,
            autDescripcionActi, autDescripcionPermi, autEmpresa, autFecha,
            autNombreVisitante, estCodigo_Estado, priCodigo_PropietarioInmueble);
    }

    public static void deleteAutorizacion(String autCodigo)
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.deleteAutorizacion(autCodigo);
    }

    public static void updateAutorizacion(String autCedVisitante,
        String autCodigo, String autDescripcionActi,
        String autDescripcionPermi, String autEmpresa, Date autFecha,
        String autNombreVisitante, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        autorizacionLogic.updateAutorizacion(autCedVisitante, autCodigo,
            autDescripcionActi, autDescripcionPermi, autEmpresa, autFecha,
            autNombreVisitante, estCodigo_Estado, priCodigo_PropietarioInmueble);
    }

    public static Autorizacion getAutorizacion(String autCodigo)
        throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();
        Autorizacion autorizacion = null;

        try {
            autorizacion = autorizacionLogic.getAutorizacion(autCodigo);
        } catch (Exception e) {
            throw e;
        }

        return autorizacion;
    }

    public static List<Autorizacion> findByCriteriaInAutorizacion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Autorizacion> findPageAutorizacion(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findPageAutorizacion(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberAutorizacion() throws Exception {
        IAutorizacionLogic autorizacionLogic = new AutorizacionLogic();

        return autorizacionLogic.findTotalNumberAutorizacion();
    }

    public static List<Ciudad> getCiudad() throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.getCiudad();
    }

    public static void saveCiudad(String ciuCodigo, String ciuNombre,
        String estCodigo_Estado, String paiCodigo_Pais)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.saveCiudad(ciuCodigo, ciuNombre, estCodigo_Estado,
            paiCodigo_Pais);
    }

    public static void deleteCiudad(String ciuCodigo) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.deleteCiudad(ciuCodigo);
    }

    public static void updateCiudad(String ciuCodigo, String ciuNombre,
        String estCodigo_Estado, String paiCodigo_Pais)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        ciudadLogic.updateCiudad(ciuCodigo, ciuNombre, estCodigo_Estado,
            paiCodigo_Pais);
    }

    public static Ciudad getCiudad(String ciuCodigo) throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();
        Ciudad ciudad = null;

        try {
            ciudad = ciudadLogic.getCiudad(ciuCodigo);
        } catch (Exception e) {
            throw e;
        }

        return ciudad;
    }

    public static List<Ciudad> findByCriteriaInCiudad(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Ciudad> findPageCiudad(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findPageCiudad(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCiudad() throws Exception {
        ICiudadLogic ciudadLogic = new CiudadLogic();

        return ciudadLogic.findTotalNumberCiudad();
    }

    public static List<Concepto> getConcepto() throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.getConcepto();
    }

    public static void saveConcepto(String conCodigo, Long conPorcentajeImpre,
        Float conValor, String preCodigo_Presupuesto,
        String tcaCodigo_TipoCategoria, String tcoCodigo_TipoConcepto)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.saveConcepto(conCodigo, conPorcentajeImpre, conValor,
            preCodigo_Presupuesto, tcaCodigo_TipoCategoria,
            tcoCodigo_TipoConcepto);
    }

    public static void deleteConcepto(String conCodigo)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.deleteConcepto(conCodigo);
    }

    public static void updateConcepto(String conCodigo,
        Long conPorcentajeImpre, Float conValor, String preCodigo_Presupuesto,
        String tcaCodigo_TipoCategoria, String tcoCodigo_TipoConcepto)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        conceptoLogic.updateConcepto(conCodigo, conPorcentajeImpre, conValor,
            preCodigo_Presupuesto, tcaCodigo_TipoCategoria,
            tcoCodigo_TipoConcepto);
    }

    public static Concepto getConcepto(String conCodigo)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();
        Concepto concepto = null;

        try {
            concepto = conceptoLogic.getConcepto(conCodigo);
        } catch (Exception e) {
            throw e;
        }

        return concepto;
    }

    public static List<Concepto> findByCriteriaInConcepto(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Concepto> findPageConcepto(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findPageConcepto(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberConcepto() throws Exception {
        IConceptoLogic conceptoLogic = new ConceptoLogic();

        return conceptoLogic.findTotalNumberConcepto();
    }

    public static List<Correspondencia> getCorrespondencia()
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.getCorrespondencia();
    }

    public static void saveCorrespondencia(String corAsunto, String corCodigo,
        String tpcCodigo_TipoCorrespondencia) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.saveCorrespondencia(corAsunto, corCodigo,
            tpcCodigo_TipoCorrespondencia);
    }

    public static void deleteCorrespondencia(String corCodigo)
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.deleteCorrespondencia(corCodigo);
    }

    public static void updateCorrespondencia(String corAsunto,
        String corCodigo, String tpcCodigo_TipoCorrespondencia)
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        correspondenciaLogic.updateCorrespondencia(corAsunto, corCodigo,
            tpcCodigo_TipoCorrespondencia);
    }

    public static Correspondencia getCorrespondencia(String corCodigo)
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
        Correspondencia correspondencia = null;

        try {
            correspondencia = correspondenciaLogic.getCorrespondencia(corCodigo);
        } catch (Exception e) {
            throw e;
        }

        return correspondencia;
    }

    public static List<Correspondencia> findByCriteriaInCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Correspondencia> findPageCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findPageCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberCorrespondencia()
        throws Exception {
        ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();

        return correspondenciaLogic.findTotalNumberCorrespondencia();
    }

    public static List<Cuenta> getCuenta() throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.getCuenta();
    }

    public static void saveCuenta(String cueCodCuenta, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble) throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        cuentaLogic.saveCuenta(cueCodCuenta, estCodigo_Estado,
            priCodigo_PropietarioInmueble);
    }

    public static void deleteCuenta(String cueCodCuenta)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        cuentaLogic.deleteCuenta(cueCodCuenta);
    }

    public static void updateCuenta(String cueCodCuenta,
        String estCodigo_Estado, String priCodigo_PropietarioInmueble)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        cuentaLogic.updateCuenta(cueCodCuenta, estCodigo_Estado,
            priCodigo_PropietarioInmueble);
    }

    public static Cuenta getCuenta(String cueCodCuenta)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();
        Cuenta cuenta = null;

        try {
            cuenta = cuentaLogic.getCuenta(cueCodCuenta);
        } catch (Exception e) {
            throw e;
        }

        return cuenta;
    }

    public static List<Cuenta> findByCriteriaInCuenta(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Cuenta> findPageCuenta(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findPageCuenta(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberCuenta() throws Exception {
        ICuentaLogic cuentaLogic = new CuentaLogic();

        return cuentaLogic.findTotalNumberCuenta();
    }

    public static List<DetalleCorrespondencia> getDetalleCorrespondencia()
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.getDetalleCorrespondencia();
    }

    public static void saveDetalleCorrespondencia(String dtcCodigo,
        Date dtcFechaEnvio, String corCodigo_Correspondencia,
        String estCodigo_Estado, String perCedula_Persona)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.saveDetalleCorrespondencia(dtcCodigo,
            dtcFechaEnvio, corCodigo_Correspondencia, estCodigo_Estado,
            perCedula_Persona);
    }

    public static void deleteDetalleCorrespondencia(String dtcCodigo)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.deleteDetalleCorrespondencia(dtcCodigo);
    }

    public static void updateDetalleCorrespondencia(String dtcCodigo,
        Date dtcFechaEnvio, String corCodigo_Correspondencia,
        String estCodigo_Estado, String perCedula_Persona)
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        detalleCorrespondenciaLogic.updateDetalleCorrespondencia(dtcCodigo,
            dtcFechaEnvio, corCodigo_Correspondencia, estCodigo_Estado,
            perCedula_Persona);
    }

    public static DetalleCorrespondencia getDetalleCorrespondencia(
        String dtcCodigo) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();
        DetalleCorrespondencia detalleCorrespondencia = null;

        try {
            detalleCorrespondencia = detalleCorrespondenciaLogic.getDetalleCorrespondencia(dtcCodigo);
        } catch (Exception e) {
            throw e;
        }

        return detalleCorrespondencia;
    }

    public static List<DetalleCorrespondencia> findByCriteriaInDetalleCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<DetalleCorrespondencia> findPageDetalleCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findPageDetalleCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDetalleCorrespondencia()
        throws Exception {
        IDetalleCorrespondenciaLogic detalleCorrespondenciaLogic = new DetalleCorrespondenciaLogic();

        return detalleCorrespondenciaLogic.findTotalNumberDetalleCorrespondencia();
    }

    public static List<DetalleFactura> getDetalleFactura()
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.getDetalleFactura();
    }

    public static void saveDetalleFactura(String dtfCodigo, Float dtfValor,
        String facCodigo_Factura, String mviCodigo_MovMesInmueble,
        String rubCodigo_Rubro) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.saveDetalleFactura(dtfCodigo, dtfValor,
            facCodigo_Factura, mviCodigo_MovMesInmueble, rubCodigo_Rubro);
    }

    public static void deleteDetalleFactura(String dtfCodigo)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.deleteDetalleFactura(dtfCodigo);
    }

    public static void updateDetalleFactura(String dtfCodigo, Float dtfValor,
        String facCodigo_Factura, String mviCodigo_MovMesInmueble,
        String rubCodigo_Rubro) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        detalleFacturaLogic.updateDetalleFactura(dtfCodigo, dtfValor,
            facCodigo_Factura, mviCodigo_MovMesInmueble, rubCodigo_Rubro);
    }

    public static DetalleFactura getDetalleFactura(String dtfCodigo)
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();
        DetalleFactura detalleFactura = null;

        try {
            detalleFactura = detalleFacturaLogic.getDetalleFactura(dtfCodigo);
        } catch (Exception e) {
            throw e;
        }

        return detalleFactura;
    }

    public static List<DetalleFactura> findByCriteriaInDetalleFactura(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<DetalleFactura> findPageDetalleFactura(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findPageDetalleFactura(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberDetalleFactura()
        throws Exception {
        IDetalleFacturaLogic detalleFacturaLogic = new DetalleFacturaLogic();

        return detalleFacturaLogic.findTotalNumberDetalleFactura();
    }

    public static List<Division> getDivision() throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.getDivision();
    }

    public static void saveDivision(String divCodigo, String divNombre,
        String estCodigo_Estado, String unrNit_UnidadResidencial)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.saveDivision(divCodigo, divNombre, estCodigo_Estado,
            unrNit_UnidadResidencial);
    }

    public static void deleteDivision(String divCodigo)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.deleteDivision(divCodigo);
    }

    public static void updateDivision(String divCodigo, String divNombre,
        String estCodigo_Estado, String unrNit_UnidadResidencial)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        divisionLogic.updateDivision(divCodigo, divNombre, estCodigo_Estado,
            unrNit_UnidadResidencial);
    }

    public static Division getDivision(String divCodigo)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();
        Division division = null;

        try {
            division = divisionLogic.getDivision(divCodigo);
        } catch (Exception e) {
            throw e;
        }

        return division;
    }

    public static List<Division> findByCriteriaInDivision(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Division> findPageDivision(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findPageDivision(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberDivision() throws Exception {
        IDivisionLogic divisionLogic = new DivisionLogic();

        return divisionLogic.findTotalNumberDivision();
    }

    public static List<Estado> getEstado() throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.getEstado();
    }

    public static void saveEstado(String estCodigo, String estNombre)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.saveEstado(estCodigo, estNombre);
    }

    public static void deleteEstado(String estCodigo) throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.deleteEstado(estCodigo);
    }

    public static void updateEstado(String estCodigo, String estNombre)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        estadoLogic.updateEstado(estCodigo, estNombre);
    }

    public static Estado getEstado(String estCodigo) throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();
        Estado estado = null;

        try {
            estado = estadoLogic.getEstado(estCodigo);
        } catch (Exception e) {
            throw e;
        }

        return estado;
    }

    public static List<Estado> findByCriteriaInEstado(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Estado> findPageEstado(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findPageEstado(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberEstado() throws Exception {
        IEstadoLogic estadoLogic = new EstadoLogic();

        return estadoLogic.findTotalNumberEstado();
    }

    public static List<Factura> getFactura() throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.getFactura();
    }

    public static void saveFactura(String facCodigo, Date facFecha,
        String cueCodCuenta_Cuenta, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble) throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.saveFactura(facCodigo, facFecha, cueCodCuenta_Cuenta,
            estCodigo_Estado, priCodigo_PropietarioInmueble);
    }

    public static void deleteFactura(String facCodigo)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.deleteFactura(facCodigo);
    }

    public static void updateFactura(String facCodigo, Date facFecha,
        String cueCodCuenta_Cuenta, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble) throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        facturaLogic.updateFactura(facCodigo, facFecha, cueCodCuenta_Cuenta,
            estCodigo_Estado, priCodigo_PropietarioInmueble);
    }

    public static Factura getFactura(String facCodigo)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();
        Factura factura = null;

        try {
            factura = facturaLogic.getFactura(facCodigo);
        } catch (Exception e) {
            throw e;
        }

        return factura;
    }

    public static List<Factura> findByCriteriaInFactura(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Factura> findPageFactura(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findPageFactura(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberFactura() throws Exception {
        IFacturaLogic facturaLogic = new FacturaLogic();

        return facturaLogic.findTotalNumberFactura();
    }

    public static List<GrupoFamiliar> getGrupoFamiliar()
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.getGrupoFamiliar();
    }

    public static void saveGrupoFamiliar(String grfCodigo,
        String estCodigo_Estado, String perCedula_Persona,
        String priCodigo_PropietarioInmueble) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.saveGrupoFamiliar(grfCodigo, estCodigo_Estado,
            perCedula_Persona, priCodigo_PropietarioInmueble);
    }

    public static void deleteGrupoFamiliar(String grfCodigo)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.deleteGrupoFamiliar(grfCodigo);
    }

    public static void updateGrupoFamiliar(String grfCodigo,
        String estCodigo_Estado, String perCedula_Persona,
        String priCodigo_PropietarioInmueble) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        grupoFamiliarLogic.updateGrupoFamiliar(grfCodigo, estCodigo_Estado,
            perCedula_Persona, priCodigo_PropietarioInmueble);
    }

    public static GrupoFamiliar getGrupoFamiliar(String grfCodigo)
        throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();
        GrupoFamiliar grupoFamiliar = null;

        try {
            grupoFamiliar = grupoFamiliarLogic.getGrupoFamiliar(grfCodigo);
        } catch (Exception e) {
            throw e;
        }

        return grupoFamiliar;
    }

    public static List<GrupoFamiliar> findByCriteriaInGrupoFamiliar(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<GrupoFamiliar> findPageGrupoFamiliar(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findPageGrupoFamiliar(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberGrupoFamiliar() throws Exception {
        IGrupoFamiliarLogic grupoFamiliarLogic = new GrupoFamiliarLogic();

        return grupoFamiliarLogic.findTotalNumberGrupoFamiliar();
    }

    public static List<Inmueble> getInmueble() throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.getInmueble();
    }

    public static void saveInmueble(Long inmCuotaAdmin, Long inmDimension,
        String inmNumeroId, String divCodigo_Division, String estCodigo_Estado)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.saveInmueble(inmCuotaAdmin, inmDimension, inmNumeroId,
            divCodigo_Division, estCodigo_Estado);
    }

    public static void deleteInmueble(String inmNumeroId)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.deleteInmueble(inmNumeroId);
    }

    public static void updateInmueble(Long inmCuotaAdmin, Long inmDimension,
        String inmNumeroId, String divCodigo_Division, String estCodigo_Estado)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        inmuebleLogic.updateInmueble(inmCuotaAdmin, inmDimension, inmNumeroId,
            divCodigo_Division, estCodigo_Estado);
    }

    public static Inmueble getInmueble(String inmNumeroId)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();
        Inmueble inmueble = null;

        try {
            inmueble = inmuebleLogic.getInmueble(inmNumeroId);
        } catch (Exception e) {
            throw e;
        }

        return inmueble;
    }

    public static List<Inmueble> findByCriteriaInInmueble(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Inmueble> findPageInmueble(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findPageInmueble(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberInmueble() throws Exception {
        IInmuebleLogic inmuebleLogic = new InmuebleLogic();

        return inmuebleLogic.findTotalNumberInmueble();
    }

    public static List<MovMesInmueble> getMovMesInmueble()
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.getMovMesInmueble();
    }

    public static void saveMovMesInmueble(String mviCodigo, Date mviFecha,
        String inmNumeroId_Inmueble, String mulCodigo_Multa,
        String zocCodigo_ZonaComun, String zneCodigo_ZonaExtra)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.saveMovMesInmueble(mviCodigo, mviFecha,
            inmNumeroId_Inmueble, mulCodigo_Multa, zocCodigo_ZonaComun,
            zneCodigo_ZonaExtra);
    }

    public static void deleteMovMesInmueble(String mviCodigo)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.deleteMovMesInmueble(mviCodigo);
    }

    public static void updateMovMesInmueble(String mviCodigo, Date mviFecha,
        String inmNumeroId_Inmueble, String mulCodigo_Multa,
        String zocCodigo_ZonaComun, String zneCodigo_ZonaExtra)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        movMesInmuebleLogic.updateMovMesInmueble(mviCodigo, mviFecha,
            inmNumeroId_Inmueble, mulCodigo_Multa, zocCodigo_ZonaComun,
            zneCodigo_ZonaExtra);
    }

    public static MovMesInmueble getMovMesInmueble(String mviCodigo)
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();
        MovMesInmueble movMesInmueble = null;

        try {
            movMesInmueble = movMesInmuebleLogic.getMovMesInmueble(mviCodigo);
        } catch (Exception e) {
            throw e;
        }

        return movMesInmueble;
    }

    public static List<MovMesInmueble> findByCriteriaInMovMesInmueble(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<MovMesInmueble> findPageMovMesInmueble(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findPageMovMesInmueble(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberMovMesInmueble()
        throws Exception {
        IMovMesInmuebleLogic movMesInmuebleLogic = new MovMesInmuebleLogic();

        return movMesInmuebleLogic.findTotalNumberMovMesInmueble();
    }

    public static List<Multa> getMulta() throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.getMulta();
    }

    public static void saveMulta(String mulCodigo, Long mulValor,
        String multNombre) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.saveMulta(mulCodigo, mulValor, multNombre);
    }

    public static void deleteMulta(String mulCodigo) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.deleteMulta(mulCodigo);
    }

    public static void updateMulta(String mulCodigo, Long mulValor,
        String multNombre) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        multaLogic.updateMulta(mulCodigo, mulValor, multNombre);
    }

    public static Multa getMulta(String mulCodigo) throws Exception {
        IMultaLogic multaLogic = new MultaLogic();
        Multa multa = null;

        try {
            multa = multaLogic.getMulta(mulCodigo);
        } catch (Exception e) {
            throw e;
        }

        return multa;
    }

    public static List<Multa> findByCriteriaInMulta(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Multa> findPageMulta(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findPageMulta(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberMulta() throws Exception {
        IMultaLogic multaLogic = new MultaLogic();

        return multaLogic.findTotalNumberMulta();
    }

    public static List<Pais> getPais() throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.getPais();
    }

    public static void savePais(String paiCodigo, String paiNombre,
        String estCodigo_Estado) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.savePais(paiCodigo, paiNombre, estCodigo_Estado);
    }

    public static void deletePais(String paiCodigo) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.deletePais(paiCodigo);
    }

    public static void updatePais(String paiCodigo, String paiNombre,
        String estCodigo_Estado) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        paisLogic.updatePais(paiCodigo, paiNombre, estCodigo_Estado);
    }

    public static Pais getPais(String paiCodigo) throws Exception {
        IPaisLogic paisLogic = new PaisLogic();
        Pais pais = null;

        try {
            pais = paisLogic.getPais(paiCodigo);
        } catch (Exception e) {
            throw e;
        }

        return pais;
    }

    public static List<Pais> findByCriteriaInPais(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Pais> findPagePais(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findPagePais(sortColumnName, sortAscending, startRow,
            maxResults);
    }

    public static Long findTotalNumberPais() throws Exception {
        IPaisLogic paisLogic = new PaisLogic();

        return paisLogic.findTotalNumberPais();
    }

    public static List<Persona> getPersona() throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.getPersona();
    }

    public static void savePersona(String perCedula, String perCelular,
        String perCorreo, String perPrimerApelli, String perPrimerNom,
        String perSegundoApelli, String perSegundoNom, String perTelefono,
        String estCodigo_Estado, String tipCodigoDoc_TipoDocumento,
        String tipCodigoP_TipoPersona) throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.savePersona(perCedula, perCelular, perCorreo,
            perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
            perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
            tipCodigoP_TipoPersona);
    }

    public static void deletePersona(String perCedula)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.deletePersona(perCedula);
    }

    public static void updatePersona(String perCedula, String perCelular,
        String perCorreo, String perPrimerApelli, String perPrimerNom,
        String perSegundoApelli, String perSegundoNom, String perTelefono,
        String estCodigo_Estado, String tipCodigoDoc_TipoDocumento,
        String tipCodigoP_TipoPersona) throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        personaLogic.updatePersona(perCedula, perCelular, perCorreo,
            perPrimerApelli, perPrimerNom, perSegundoApelli, perSegundoNom,
            perTelefono, estCodigo_Estado, tipCodigoDoc_TipoDocumento,
            tipCodigoP_TipoPersona);
    }

    public static Persona getPersona(String perCedula)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();
        Persona persona = null;

        try {
            persona = personaLogic.getPersona(perCedula);
        } catch (Exception e) {
            throw e;
        }

        return persona;
    }

    public static List<Persona> findByCriteriaInPersona(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Persona> findPagePersona(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findPagePersona(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberPersona() throws Exception {
        IPersonaLogic personaLogic = new PersonaLogic();

        return personaLogic.findTotalNumberPersona();
    }

    public static List<Presupuesto> getPresupuesto() throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.getPresupuesto();
    }

    public static void savePresupuesto(String preCodigo, Date preFecha,
        Float preValorTotal, String estCodigo_Estado,
        String unrNit_UnidadResidencial) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.savePresupuesto(preCodigo, preFecha, preValorTotal,
            estCodigo_Estado, unrNit_UnidadResidencial);
    }

    public static void deletePresupuesto(String preCodigo)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.deletePresupuesto(preCodigo);
    }

    public static void updatePresupuesto(String preCodigo, Date preFecha,
        Float preValorTotal, String estCodigo_Estado,
        String unrNit_UnidadResidencial) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        presupuestoLogic.updatePresupuesto(preCodigo, preFecha, preValorTotal,
            estCodigo_Estado, unrNit_UnidadResidencial);
    }

    public static Presupuesto getPresupuesto(String preCodigo)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();
        Presupuesto presupuesto = null;

        try {
            presupuesto = presupuestoLogic.getPresupuesto(preCodigo);
        } catch (Exception e) {
            throw e;
        }

        return presupuesto;
    }

    public static List<Presupuesto> findByCriteriaInPresupuesto(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Presupuesto> findPagePresupuesto(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findPagePresupuesto(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPresupuesto() throws Exception {
        IPresupuestoLogic presupuestoLogic = new PresupuestoLogic();

        return presupuestoLogic.findTotalNumberPresupuesto();
    }

    public static List<PropietarioInmueble> getPropietarioInmueble()
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.getPropietarioInmueble();
    }

    public static void savePropietarioInmueble(String priCodigo,
        String estCodigo_Estado, String inmNumeroId_Inmueble,
        String perCedula_Persona) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.savePropietarioInmueble(priCodigo,
            estCodigo_Estado, inmNumeroId_Inmueble, perCedula_Persona);
    }

    public static void deletePropietarioInmueble(String priCodigo)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.deletePropietarioInmueble(priCodigo);
    }

    public static void updatePropietarioInmueble(String priCodigo,
        String estCodigo_Estado, String inmNumeroId_Inmueble,
        String perCedula_Persona) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        propietarioInmuebleLogic.updatePropietarioInmueble(priCodigo,
            estCodigo_Estado, inmNumeroId_Inmueble, perCedula_Persona);
    }

    public static PropietarioInmueble getPropietarioInmueble(String priCodigo)
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();
        PropietarioInmueble propietarioInmueble = null;

        try {
            propietarioInmueble = propietarioInmuebleLogic.getPropietarioInmueble(priCodigo);
        } catch (Exception e) {
            throw e;
        }

        return propietarioInmueble;
    }

    public static List<PropietarioInmueble> findByCriteriaInPropietarioInmueble(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<PropietarioInmueble> findPagePropietarioInmueble(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findPagePropietarioInmueble(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberPropietarioInmueble()
        throws Exception {
        IPropietarioInmuebleLogic propietarioInmuebleLogic = new PropietarioInmuebleLogic();

        return propietarioInmuebleLogic.findTotalNumberPropietarioInmueble();
    }

    public static List<Recepcion> getRecepcion() throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.getRecepcion();
    }

    public static void saveRecepcion(String observacion,
        String recCodRecepcion, Date recFechaRecepcion,
        String corCodigo_Correspondencia, String usuCodigo_Usuario)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.saveRecepcion(observacion, recCodRecepcion,
            recFechaRecepcion, corCodigo_Correspondencia, usuCodigo_Usuario);
    }

    public static void deleteRecepcion(String recCodRecepcion)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.deleteRecepcion(recCodRecepcion);
    }

    public static void updateRecepcion(String observacion,
        String recCodRecepcion, Date recFechaRecepcion,
        String corCodigo_Correspondencia, String usuCodigo_Usuario)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        recepcionLogic.updateRecepcion(observacion, recCodRecepcion,
            recFechaRecepcion, corCodigo_Correspondencia, usuCodigo_Usuario);
    }

    public static Recepcion getRecepcion(String recCodRecepcion)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();
        Recepcion recepcion = null;

        try {
            recepcion = recepcionLogic.getRecepcion(recCodRecepcion);
        } catch (Exception e) {
            throw e;
        }

        return recepcion;
    }

    public static List<Recepcion> findByCriteriaInRecepcion(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Recepcion> findPageRecepcion(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findPageRecepcion(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberRecepcion() throws Exception {
        IRecepcionLogic recepcionLogic = new RecepcionLogic();

        return recepcionLogic.findTotalNumberRecepcion();
    }

    public static List<Reserva> getReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.getReserva();
    }

    public static void saveReserva(String resCodigo, Date resFecha,
        Date resHoraFin, Date resHoraInicio, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble, String zocCodigo_ZonaComun)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.saveReserva(resCodigo, resFecha, resHoraFin,
            resHoraInicio, estCodigo_Estado, priCodigo_PropietarioInmueble,
            zocCodigo_ZonaComun);
    }

    public static void deleteReserva(String resCodigo)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.deleteReserva(resCodigo);
    }

    public static void updateReserva(String resCodigo, Date resFecha,
        Date resHoraFin, Date resHoraInicio, String estCodigo_Estado,
        String priCodigo_PropietarioInmueble, String zocCodigo_ZonaComun)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        reservaLogic.updateReserva(resCodigo, resFecha, resHoraFin,
            resHoraInicio, estCodigo_Estado, priCodigo_PropietarioInmueble,
            zocCodigo_ZonaComun);
    }

    public static Reserva getReserva(String resCodigo)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        Reserva reserva = null;

        try {
            reserva = reservaLogic.getReserva(resCodigo);
        } catch (Exception e) {
            throw e;
        }

        return reserva;
    }

    public static List<Reserva> findByCriteriaInReserva(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Reserva> findPageReserva(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findPageReserva(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();

        return reservaLogic.findTotalNumberReserva();
    }

    public static List<Rubro> getRubro() throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.getRubro();
    }

    public static void saveRubro(String rubCodigo, String rubNombre)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.saveRubro(rubCodigo, rubNombre);
    }

    public static void deleteRubro(String rubCodigo) throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.deleteRubro(rubCodigo);
    }

    public static void updateRubro(String rubCodigo, String rubNombre)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        rubroLogic.updateRubro(rubCodigo, rubNombre);
    }

    public static Rubro getRubro(String rubCodigo) throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();
        Rubro rubro = null;

        try {
            rubro = rubroLogic.getRubro(rubCodigo);
        } catch (Exception e) {
            throw e;
        }

        return rubro;
    }

    public static List<Rubro> findByCriteriaInRubro(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Rubro> findPageRubro(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findPageRubro(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberRubro() throws Exception {
        IRubroLogic rubroLogic = new RubroLogic();

        return rubroLogic.findTotalNumberRubro();
    }

    public static List<TipoCategoria> getTipoCategoria()
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.getTipoCategoria();
    }

    public static void saveTipoCategoria(String tcaCodigo, String tcaNombre)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.saveTipoCategoria(tcaCodigo, tcaNombre);
    }

    public static void deleteTipoCategoria(String tcaCodigo)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.deleteTipoCategoria(tcaCodigo);
    }

    public static void updateTipoCategoria(String tcaCodigo, String tcaNombre)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        tipoCategoriaLogic.updateTipoCategoria(tcaCodigo, tcaNombre);
    }

    public static TipoCategoria getTipoCategoria(String tcaCodigo)
        throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();
        TipoCategoria tipoCategoria = null;

        try {
            tipoCategoria = tipoCategoriaLogic.getTipoCategoria(tcaCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoCategoria;
    }

    public static List<TipoCategoria> findByCriteriaInTipoCategoria(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoCategoria> findPageTipoCategoria(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findPageTipoCategoria(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoCategoria() throws Exception {
        ITipoCategoriaLogic tipoCategoriaLogic = new TipoCategoriaLogic();

        return tipoCategoriaLogic.findTotalNumberTipoCategoria();
    }

    public static List<TipoConcepto> getTipoConcepto()
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.getTipoConcepto();
    }

    public static void saveTipoConcepto(String tcoCodigo, String tcoNombre)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.saveTipoConcepto(tcoCodigo, tcoNombre);
    }

    public static void deleteTipoConcepto(String tcoCodigo)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.deleteTipoConcepto(tcoCodigo);
    }

    public static void updateTipoConcepto(String tcoCodigo, String tcoNombre)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        tipoConceptoLogic.updateTipoConcepto(tcoCodigo, tcoNombre);
    }

    public static TipoConcepto getTipoConcepto(String tcoCodigo)
        throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();
        TipoConcepto tipoConcepto = null;

        try {
            tipoConcepto = tipoConceptoLogic.getTipoConcepto(tcoCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoConcepto;
    }

    public static List<TipoConcepto> findByCriteriaInTipoConcepto(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoConcepto> findPageTipoConcepto(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findPageTipoConcepto(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoConcepto() throws Exception {
        ITipoConceptoLogic tipoConceptoLogic = new TipoConceptoLogic();

        return tipoConceptoLogic.findTotalNumberTipoConcepto();
    }

    public static List<TipoCorrespondencia> getTipoCorrespondencia()
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.getTipoCorrespondencia();
    }

    public static void saveTipoCorrespondencia(String tpcCodigo,
        String tpcNombre) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.saveTipoCorrespondencia(tpcCodigo, tpcNombre);
    }

    public static void deleteTipoCorrespondencia(String tpcCodigo)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.deleteTipoCorrespondencia(tpcCodigo);
    }

    public static void updateTipoCorrespondencia(String tpcCodigo,
        String tpcNombre) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        tipoCorrespondenciaLogic.updateTipoCorrespondencia(tpcCodigo, tpcNombre);
    }

    public static TipoCorrespondencia getTipoCorrespondencia(String tpcCodigo)
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();
        TipoCorrespondencia tipoCorrespondencia = null;

        try {
            tipoCorrespondencia = tipoCorrespondenciaLogic.getTipoCorrespondencia(tpcCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoCorrespondencia;
    }

    public static List<TipoCorrespondencia> findByCriteriaInTipoCorrespondencia(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<TipoCorrespondencia> findPageTipoCorrespondencia(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findPageTipoCorrespondencia(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoCorrespondencia()
        throws Exception {
        ITipoCorrespondenciaLogic tipoCorrespondenciaLogic = new TipoCorrespondenciaLogic();

        return tipoCorrespondenciaLogic.findTotalNumberTipoCorrespondencia();
    }

    public static List<TipoDocumento> getTipoDocumento()
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.getTipoDocumento();
    }

    public static void saveTipoDocumento(String tipCodigoDoc,
        String tipNombreDoc) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.saveTipoDocumento(tipCodigoDoc, tipNombreDoc);
    }

    public static void deleteTipoDocumento(String tipCodigoDoc)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.deleteTipoDocumento(tipCodigoDoc);
    }

    public static void updateTipoDocumento(String tipCodigoDoc,
        String tipNombreDoc) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        tipoDocumentoLogic.updateTipoDocumento(tipCodigoDoc, tipNombreDoc);
    }

    public static TipoDocumento getTipoDocumento(String tipCodigoDoc)
        throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();
        TipoDocumento tipoDocumento = null;

        try {
            tipoDocumento = tipoDocumentoLogic.getTipoDocumento(tipCodigoDoc);
        } catch (Exception e) {
            throw e;
        }

        return tipoDocumento;
    }

    public static List<TipoDocumento> findByCriteriaInTipoDocumento(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoDocumento> findPageTipoDocumento(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findPageTipoDocumento(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoDocumento() throws Exception {
        ITipoDocumentoLogic tipoDocumentoLogic = new TipoDocumentoLogic();

        return tipoDocumentoLogic.findTotalNumberTipoDocumento();
    }

    public static List<TipoPersona> getTipoPersona() throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

        return tipoPersonaLogic.getTipoPersona();
    }

    public static void saveTipoPersona(String tipCodigoP, String tipNombreP)
        throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
        tipoPersonaLogic.saveTipoPersona(tipCodigoP, tipNombreP);
    }

    public static void deleteTipoPersona(String tipCodigoP)
        throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
        tipoPersonaLogic.deleteTipoPersona(tipCodigoP);
    }

    public static void updateTipoPersona(String tipCodigoP, String tipNombreP)
        throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
        tipoPersonaLogic.updateTipoPersona(tipCodigoP, tipNombreP);
    }

    public static TipoPersona getTipoPersona(String tipCodigoP)
        throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();
        TipoPersona tipoPersona = null;

        try {
            tipoPersona = tipoPersonaLogic.getTipoPersona(tipCodigoP);
        } catch (Exception e) {
            throw e;
        }

        return tipoPersona;
    }

    public static List<TipoPersona> findByCriteriaInTipoPersona(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

        return tipoPersonaLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoPersona> findPageTipoPersona(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

        return tipoPersonaLogic.findPageTipoPersona(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoPersona() throws Exception {
        ITipoPersonaLogic tipoPersonaLogic = new TipoPersonaLogic();

        return tipoPersonaLogic.findTotalNumberTipoPersona();
    }

    public static List<TipoUsuario> getTipoUsuario() throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.getTipoUsuario();
    }

    public static void saveTipoUsuario(String tpuCodigo, String tpuNombre)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.saveTipoUsuario(tpuCodigo, tpuNombre);
    }

    public static void deleteTipoUsuario(String tpuCodigo)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.deleteTipoUsuario(tpuCodigo);
    }

    public static void updateTipoUsuario(String tpuCodigo, String tpuNombre)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        tipoUsuarioLogic.updateTipoUsuario(tpuCodigo, tpuNombre);
    }

    public static TipoUsuario getTipoUsuario(String tpuCodigo)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();
        TipoUsuario tipoUsuario = null;

        try {
            tipoUsuario = tipoUsuarioLogic.getTipoUsuario(tpuCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoUsuario;
    }

    public static List<TipoUsuario> findByCriteriaInTipoUsuario(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoUsuario> findPageTipoUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findPageTipoUsuario(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoUsuario() throws Exception {
        ITipoUsuarioLogic tipoUsuarioLogic = new TipoUsuarioLogic();

        return tipoUsuarioLogic.findTotalNumberTipoUsuario();
    }

    public static List<TipoVehiculo> getTipoVehiculo()
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.getTipoVehiculo();
    }

    public static void saveTipoVehiculo(String tpvCodigo, String tpvNombre)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.saveTipoVehiculo(tpvCodigo, tpvNombre);
    }

    public static void deleteTipoVehiculo(String tpvCodigo)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.deleteTipoVehiculo(tpvCodigo);
    }

    public static void updateTipoVehiculo(String tpvCodigo, String tpvNombre)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        tipoVehiculoLogic.updateTipoVehiculo(tpvCodigo, tpvNombre);
    }

    public static TipoVehiculo getTipoVehiculo(String tpvCodigo)
        throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();
        TipoVehiculo tipoVehiculo = null;

        try {
            tipoVehiculo = tipoVehiculoLogic.getTipoVehiculo(tpvCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoVehiculo;
    }

    public static List<TipoVehiculo> findByCriteriaInTipoVehiculo(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoVehiculo> findPageTipoVehiculo(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findPageTipoVehiculo(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoVehiculo() throws Exception {
        ITipoVehiculoLogic tipoVehiculoLogic = new TipoVehiculoLogic();

        return tipoVehiculoLogic.findTotalNumberTipoVehiculo();
    }

    public static List<TipoZonaComun> getTipoZonaComun()
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.getTipoZonaComun();
    }

    public static void saveTipoZonaComun(String tzcCodigo, String tzcNombre)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.saveTipoZonaComun(tzcCodigo, tzcNombre);
    }

    public static void deleteTipoZonaComun(String tzcCodigo)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.deleteTipoZonaComun(tzcCodigo);
    }

    public static void updateTipoZonaComun(String tzcCodigo, String tzcNombre)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        tipoZonaComunLogic.updateTipoZonaComun(tzcCodigo, tzcNombre);
    }

    public static TipoZonaComun getTipoZonaComun(String tzcCodigo)
        throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();
        TipoZonaComun tipoZonaComun = null;

        try {
            tipoZonaComun = tipoZonaComunLogic.getTipoZonaComun(tzcCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoZonaComun;
    }

    public static List<TipoZonaComun> findByCriteriaInTipoZonaComun(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoZonaComun> findPageTipoZonaComun(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findPageTipoZonaComun(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoZonaComun() throws Exception {
        ITipoZonaComunLogic tipoZonaComunLogic = new TipoZonaComunLogic();

        return tipoZonaComunLogic.findTotalNumberTipoZonaComun();
    }

    public static List<TipoZonaExtra> getTipoZonaExtra()
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.getTipoZonaExtra();
    }

    public static void saveTipoZonaExtra(String tzeCodigo, String tzeNombre)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.saveTipoZonaExtra(tzeCodigo, tzeNombre);
    }

    public static void deleteTipoZonaExtra(String tzeCodigo)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.deleteTipoZonaExtra(tzeCodigo);
    }

    public static void updateTipoZonaExtra(String tzeCodigo, String tzeNombre)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        tipoZonaExtraLogic.updateTipoZonaExtra(tzeCodigo, tzeNombre);
    }

    public static TipoZonaExtra getTipoZonaExtra(String tzeCodigo)
        throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();
        TipoZonaExtra tipoZonaExtra = null;

        try {
            tipoZonaExtra = tipoZonaExtraLogic.getTipoZonaExtra(tzeCodigo);
        } catch (Exception e) {
            throw e;
        }

        return tipoZonaExtra;
    }

    public static List<TipoZonaExtra> findByCriteriaInTipoZonaExtra(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<TipoZonaExtra> findPageTipoZonaExtra(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findPageTipoZonaExtra(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberTipoZonaExtra() throws Exception {
        ITipoZonaExtraLogic tipoZonaExtraLogic = new TipoZonaExtraLogic();

        return tipoZonaExtraLogic.findTotalNumberTipoZonaExtra();
    }

    public static List<UnidadResidencial> getUnidadResidencial()
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.getUnidadResidencial();
    }

    public static void saveUnidadResidencial(String unrBarrio,
        String unrDireccion, String unrNit, String unrNombre,
        String unrTelefono, String admCodigo_Administrador,
        String ciuCodigo_Ciudad, String estCodigo_Estado)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.saveUnidadResidencial(unrBarrio, unrDireccion,
            unrNit, unrNombre, unrTelefono, admCodigo_Administrador,
            ciuCodigo_Ciudad, estCodigo_Estado);
    }

    public static void deleteUnidadResidencial(String unrNit)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.deleteUnidadResidencial(unrNit);
    }

    public static void updateUnidadResidencial(String unrBarrio,
        String unrDireccion, String unrNit, String unrNombre,
        String unrTelefono, String admCodigo_Administrador,
        String ciuCodigo_Ciudad, String estCodigo_Estado)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        unidadResidencialLogic.updateUnidadResidencial(unrBarrio, unrDireccion,
            unrNit, unrNombre, unrTelefono, admCodigo_Administrador,
            ciuCodigo_Ciudad, estCodigo_Estado);
    }
    
  
    public static UnidadResidencial getUnidadResidencial(String unrNit)
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();
        UnidadResidencial unidadResidencial = null;

        try {
            unidadResidencial = unidadResidencialLogic.getUnidadResidencial(unrNit);
        } catch (Exception e) {
            throw e;
        }

        return unidadResidencial;
    }

    public static List<UnidadResidencial> findByCriteriaInUnidadResidencial(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findByCriteria(variables,
            variablesBetween, variablesBetweenDates);
    }

    public static List<UnidadResidencial> findPageUnidadResidencial(
        String sortColumnName, boolean sortAscending, int startRow,
        int maxResults) throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findPageUnidadResidencial(sortColumnName,
            sortAscending, startRow, maxResults);
    }

    public static Long findTotalNumberUnidadResidencial()
        throws Exception {
        IUnidadResidencialLogic unidadResidencialLogic = new UnidadResidencialLogic();

        return unidadResidencialLogic.findTotalNumberUnidadResidencial();
    }

    public static List<Usuario> getUsuario() throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.getUsuario();
    }

    public static void saveUsuario(String usuCodigo, String usuContrasena,
        String usuLogin, String estCodigo_Estado, String perCedula_Persona,
        String tpuCodigo_TipoUsuario) throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.saveUsuario(usuCodigo, usuContrasena, usuLogin,
            estCodigo_Estado, perCedula_Persona, tpuCodigo_TipoUsuario);
    }

    public static void deleteUsuario(String usuCodigo)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.deleteUsuario(usuCodigo);
    }

    public static void updateUsuario(String usuCodigo, String usuContrasena,
        String usuLogin, String estCodigo_Estado, String perCedula_Persona,
        String tpuCodigo_TipoUsuario) throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        usuarioLogic.updateUsuario(usuCodigo, usuContrasena, usuLogin,
            estCodigo_Estado, perCedula_Persona, tpuCodigo_TipoUsuario);
    }

    public static Usuario getUsuario(String usuCodigo)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();
        Usuario usuario = null;

        try {
            usuario = usuarioLogic.getUsuario(usuCodigo);
        } catch (Exception e) {
            throw e;
        }

        return usuario;
    }

    public static List<Usuario> findByCriteriaInUsuario(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Usuario> findPageUsuario(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findPageUsuario(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberUsuario() throws Exception {
        IUsuarioLogic usuarioLogic = new UsuarioLogic();

        return usuarioLogic.findTotalNumberUsuario();
    }

    public static List<Vehiculo> getVehiculo() throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.getVehiculo();
    }

    public static void saveVehiculo(Date veiAno, String veiCodigo,
        String veiColor, String veiMarca, String estCodigo_Estado,
        String perCedula_Persona, String tpvCodigo_TipoVehiculo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.saveVehiculo(veiAno, veiCodigo, veiColor, veiMarca,
            estCodigo_Estado, perCedula_Persona, tpvCodigo_TipoVehiculo);
    }

    public static void deleteVehiculo(String veiCodigo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.deleteVehiculo(veiCodigo);
    }

    public static void updateVehiculo(Date veiAno, String veiCodigo,
        String veiColor, String veiMarca, String estCodigo_Estado,
        String perCedula_Persona, String tpvCodigo_TipoVehiculo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        vehiculoLogic.updateVehiculo(veiAno, veiCodigo, veiColor, veiMarca,
            estCodigo_Estado, perCedula_Persona, tpvCodigo_TipoVehiculo);
    }

    public static Vehiculo getVehiculo(String veiCodigo)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();
        Vehiculo vehiculo = null;

        try {
            vehiculo = vehiculoLogic.getVehiculo(veiCodigo);
        } catch (Exception e) {
            throw e;
        }

        return vehiculo;
    }

    public static List<Vehiculo> findByCriteriaInVehiculo(Object[] variables,
        Object[] variablesBetween, Object[] variablesBetweenDates)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<Vehiculo> findPageVehiculo(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findPageVehiculo(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberVehiculo() throws Exception {
        IVehiculoLogic vehiculoLogic = new VehiculoLogic();

        return vehiculoLogic.findTotalNumberVehiculo();
    }

    public static List<ZonaComun> getZonaComun() throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.getZonaComun();
    }

    public static void saveZonaComun(String zocCodigo, String zocNombre,
        Long zocValor, String estCodigo_Estado, String tzcCodigo_TipoZonaComun,
        String unrNit_UnidadResidencial) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.saveZonaComun(zocCodigo, zocNombre, zocValor,
            estCodigo_Estado, tzcCodigo_TipoZonaComun, unrNit_UnidadResidencial);
    }

    public static void deleteZonaComun(String zocCodigo)
        throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.deleteZonaComun(zocCodigo);
    }

    public static void updateZonaComun(String zocCodigo, String zocNombre,
        Long zocValor, String estCodigo_Estado, String tzcCodigo_TipoZonaComun,
        String unrNit_UnidadResidencial) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        zonaComunLogic.updateZonaComun(zocCodigo, zocNombre, zocValor,
            estCodigo_Estado, tzcCodigo_TipoZonaComun, unrNit_UnidadResidencial);
    }

    public static ZonaComun getZonaComun(String zocCodigo)
        throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();
        ZonaComun zonaComun = null;

        try {
            zonaComun = zonaComunLogic.getZonaComun(zocCodigo);
        } catch (Exception e) {
            throw e;
        }

        return zonaComun;
    }

    public static List<ZonaComun> findByCriteriaInZonaComun(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ZonaComun> findPageZonaComun(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findPageZonaComun(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberZonaComun() throws Exception {
        IZonaComunLogic zonaComunLogic = new ZonaComunLogic();

        return zonaComunLogic.findTotalNumberZonaComun();
    }

    public static List<ZonaExtra> getZonaExtra() throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.getZonaExtra();
    }

    public static void saveZonaExtra(String zneCodigo, Long zneDimension,
        Long zneValor, String estCodigo_Estado, String inmNumeroId_Inmueble,
        String tzeCodigo_TipoZonaExtra) throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.saveZonaExtra(zneCodigo, zneDimension, zneValor,
            estCodigo_Estado, inmNumeroId_Inmueble, tzeCodigo_TipoZonaExtra);
    }

    public static void deleteZonaExtra(String zneCodigo)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.deleteZonaExtra(zneCodigo);
    }

    public static void updateZonaExtra(String zneCodigo, Long zneDimension,
        Long zneValor, String estCodigo_Estado, String inmNumeroId_Inmueble,
        String tzeCodigo_TipoZonaExtra) throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        zonaExtraLogic.updateZonaExtra(zneCodigo, zneDimension, zneValor,
            estCodigo_Estado, inmNumeroId_Inmueble, tzeCodigo_TipoZonaExtra);
    }

    public static ZonaExtra getZonaExtra(String zneCodigo)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();
        ZonaExtra zonaExtra = null;

        try {
            zonaExtra = zonaExtraLogic.getZonaExtra(zneCodigo);
        } catch (Exception e) {
            throw e;
        }

        return zonaExtra;
    }

    public static List<ZonaExtra> findByCriteriaInZonaExtra(
        Object[] variables, Object[] variablesBetween,
        Object[] variablesBetweenDates) throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findByCriteria(variables, variablesBetween,
            variablesBetweenDates);
    }

    public static List<ZonaExtra> findPageZonaExtra(String sortColumnName,
        boolean sortAscending, int startRow, int maxResults)
        throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findPageZonaExtra(sortColumnName, sortAscending,
            startRow, maxResults);
    }

    public static Long findTotalNumberZonaExtra() throws Exception {
        IZonaExtraLogic zonaExtraLogic = new ZonaExtraLogic();

        return zonaExtraLogic.findTotalNumberZonaExtra();
    }
    
    //Metodo que trae el numero en que van las correspondencias...
    public static String darProximoNumero() throws Exception {
    	ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
    	String s = correspondenciaLogic.findTotalNumberCorrespondencia()+"";
         return s;
    }
    
    //Metodo que trae el numero en que van las reservas...
    public static String darNumberReserva() throws Exception {
        IReservaLogic reservaLogic = new ReservaLogic();
        return reservaLogic.findTotalNumberReserva()+"";
    }
    
    //Metodo que consulta las correspondencias por Numero de Cedula para llenar el DTO...
    public static List<DtoCorrespondencia> consultarDtoCorrespondencia(String cedula) throws Exception {
    	ICorrespondenciaLogic correspondenciaLogic = new CorrespondenciaLogic();
    	return correspondenciaLogic.consultarDtoCorrespondencia(cedula);
    }
    
    //metodo que llena el dataTable de autorizacion por nombre.....
    public static List<Autorizacion> consultaPorNombre_y_Usuario(String nombre, String usu) throws Exception {
		IAutorizacionLogic autorizacionlogic = new AutorizacionLogic();
    	return autorizacionlogic.consultaPorNombre_y_Usuario(nombre,usu);    	
    }
    
    //metodo que llena el dataTable de autorizacion por codigo.....
    public static List<Autorizacion> consultaPorCedula_y_Usuario(String cod, String usu) throws Exception {
		IAutorizacionLogic autorizacionlogic = new AutorizacionLogic();
    	return autorizacionlogic.consultaPorCedula_y_Usuario(cod,usu);    	
    }
    
    //Metodo que trae un usuario con el Login y password.....
    public static List<Usuario> traerUsuario(String usu,String pass) throws Exception{
    	IUsuarioLogic usuLogic = new UsuarioLogic();    	
    	return usuLogic.traerUsuario(usu,pass);
    }

    
    //metodo que trae el codigo del propietario inmueble....
    public static String getUsuarioParametro2(String perCedula)throws Exception{
    	IPropietarioInmuebleLogic prILogic = new PropietarioInmuebleLogic();
    	return prILogic.getUsuarioParametro2(perCedula);
    }    
    
    //metodo que trae el codigo del adminLocal....
    public static String traerCodigoAdminLocal(String cedula)throws Exception{
    	IAdministradorLogic administradorLogic = new AdministradorLogic();
    	return administradorLogic.traerCodigoAdminLocal(cedula);
    }    
      
  //metodod que llena el dataTable por Nombre de UnidadResidencial....
    public static List<UnidadResidencial> llenarTblNombUnRe(String nombUnid, String codAdmin)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarTblNombUnRe(nombUnid, codAdmin);
    }
    
  //metodod que llena el dataTable por Nit de UnidadResidencial....
    public static List<UnidadResidencial> llenarTblNITUnRe(String nit, String codAdmin)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarTblNITUnRe(nit, codAdmin);
    }
    
  //llena el dataTable UnidaRes por NOmbre Si es Admin GLOBAL....
    public static List<UnidadResidencial> llenarDataTableUnRes(String nombConsulta)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarDataTableUnRes(nombConsulta);
    }
    
  //llena el dataTable UnidaRes por NIT Si es Admin GLOBAL....
    public static List<UnidadResidencial> llenarDataTableUnRes2(String nit)throws Exception{
    	IUnidadResidencialLogic uniResLogic = new UnidadResidencialLogic();
    	return uniResLogic.llenarDataTableUnRes2(nit);
    }

    
}
